package com.evan.review.thread;

/**
 * 线程与线程池详解及面试要点
 *
 * 一、线程基础知识
 *
 * 1. 线程基本概念
 *    - 定义：线程是进程内的执行单元，是CPU调度的基本单位
 *    - 与进程区别：进程是资源分配的基本单位，线程是CPU调度的基本单位
 *    - 进程与线程关系：一个进程可包含多个线程，线程共享进程的资源（内存空间、文件句柄等）
 *    - Android特点：Android中一个应用就是一个进程，主线程（UI线程）负责用户界面交互
 *    - 面试考点：能清晰说明线程与进程的区别，Android中主线程的职责
 *
 * 2. 线程的生命周期（状态）
 *    - 新建状态(New)：线程对象被创建后处于此状态，还未调用start()方法
 *    - 就绪状态(Runnable)：调用start()后等待CPU分配执行时间
 *    - 运行状态(Running)：获得CPU时间片，执行run()方法
 *    - 阻塞状态(Blocked)：线程因某种原因放弃CPU使用权，暂停运行
 *      a) 等待阻塞：执行wait()方法
 *      b) 同步阻塞：等待获取synchronized同步锁
 *      c) 其他阻塞：执行sleep()或join()方法，或I/O请求
 *    - 死亡状态(Dead)：线程执行完毕或异常终止
 *    - 面试考点：理解线程状态的转换条件，尤其是阻塞和唤醒的机制
 *
 * 3. 线程的创建方式
 *    - 继承Thread类：重写run()方法，调用对象的start()方法启动线程
 *      优点：编写简单，run()内无需考虑同步问题
 *      缺点：Java单继承限制，无法继承其他类
 *    - 实现Runnable接口：实现run()方法，将对象传入Thread构造函数
 *      优点：可继承其他类，便于资源共享
 *      缺点：无法直接使用Thread类的方法，需要通过Thread.currentThread()获取
 *    - 实现Callable接口：实现call()方法，可返回结果并抛出异常
 *      优点：可获取线程执行结果和异常信息
 *      使用方式：需要结合FutureTask或线程池使用
 *    - Android特有方式：继承AsyncTask、HandlerThread、IntentService等
 *    - 面试考点：三种创建方式的区别与适用场景，尤其是Android中推荐的方式
 *
 * 4. 线程常用方法
 *    - start()：启动线程，间接调用run()方法
 *    - run()：线程的执行体，包含线程要执行的代码
 *    - sleep(long millis)：使当前线程休眠指定时间，不释放锁
 *    - yield()：暂停当前线程，让同优先级或更高优先级的线程有机会执行
 *    - join()：等待调用此方法的线程执行完毕
 *    - interrupt()：中断线程，设置中断标志位
 *    - isInterrupted()：检查线程是否被中断
 *    - setPriority(int)：设置线程优先级(1-10，默认5)
 *    - 面试考点：sleep()与wait()区别，interrupt()机制，yield()的作用
 *
 * 5. 线程间通信
 *    - wait()/notify()/notifyAll()：Object类方法，配合synchronized使用
 *      a) wait()：使线程等待，释放锁
 *      b) notify()：随机唤醒一个等待的线程
 *      c) notifyAll()：唤醒所有等待的线程
 *    - volatile关键字：保证变量可见性，防止指令重排
 *    - join()：线程同步，等待其他线程完成
 *    - CountDownLatch：允许一个或多个线程等待其他线程完成操作
 *    - CyclicBarrier：让一组线程全部达到某个状态后再继续执行
 *    - Semaphore：控制同时访问特定资源的线程数量
 *    - BlockingQueue：线程安全的队列，用于生产者消费者模式
 *    - Android中的通信：Handler消息机制，LocalBroadcastManager
 *    - 面试考点：wait/notify原理，Handler原理及优势，volatile的作用与实现机制
 *
 * 6. 线程安全与同步
 *    - 线程安全定义：多线程环境下代码能正确执行，不出现数据错误
 *    - 线程安全问题成因：资源共享、竞态条件、可见性、原子性、有序性问题
 *    - synchronized关键字：
 *      a) 同步方法：整个方法加锁
 *      b) 同步代码块：只对关键代码加锁
 *      c) 锁对象的选择：对象锁、类锁
 *    - volatile关键字：解决可见性和有序性问题，不解决原子性问题
 *    - final关键字：防止对象引用和值被修改，增强线程安全性
 *    - ThreadLocal：为每个线程提供独立的变量副本
 *    - 原子类（Atomic*）：提供原子操作，保证操作的原子性
 *    - 显式锁（Lock接口）：比synchronized更灵活的锁机制
 *      a) ReentrantLock：可重入锁，支持公平性
 *      b) ReadWriteLock：读写锁，允许并发读
 *    - Android中的同步工具：ArrayMap、SparseArray等并非线程安全集合
 *    - 面试考点：synchronized的实现原理和优化（偏向锁、轻量级锁、重量级锁），volatile的实现机制
 *
 * 7. 死锁
 *    - 定义：两个或多个线程互相等待对方持有的锁，导致永久阻塞
 *    - 产生条件：
 *      a) 互斥条件：资源同时只能被一个线程使用
 *      b) 请求与保持条件：线程已获得资源，又提出新的资源请求
 *      c) 不可剥夺条件：线程获得的资源只能由自己释放
 *      d) 循环等待条件：存在循环等待链
 *    - 预防死锁：
 *      a) 固定加锁顺序：按统一顺序获取锁
 *      b) 超时释放：使用tryLock(timeout)方法
 *      c) 死锁检测：使用工具检测死锁风险
 *    - 面试考点：如何分析和预防死锁，能手写死锁和解决方案的示例代码
 *
 * 8. 并发编程的挑战
 *    - 上下文切换开销：频繁的线程切换会导致性能下降
 *    - 内存同步开销：同步操作会降低并发性能
 *    - 阻塞导致的资源浪费：IO阻塞导致线程无法充分利用CPU
 *    - 并发错误难以重现和调试：时序依赖的Bug难以排查
 *    - 过度并发导致的性能下降：线程过多导致资源竞争和开销增加
 *    - Android中的挑战：主线程阻塞导致ANR，过多后台线程导致电池消耗
 *    - 面试考点：如何优化线程使用，减少上下文切换，避免过度并发
 *
 * 二、线程池详解
 * 
 * 1. 线程池基本概念
 *    - 定义：管理一组工作线程的资源池，重用线程避免频繁创建销毁
 *    - 优势：
 *      a) 降低资源消耗：复用线程，减少创建和销毁线程的开销
 *      b) 提高响应速度：任务到达时不需要等待线程创建
 *      c) 提高线程可管理性：统一管理，避免无限制创建
 *      d) 提供定时执行、定期执行的能力
 *    - Java线程池实现：Executor框架，顶层接口是Executor
 *    - Android对线程池的优化：系统全局线程池，AsyncTask内部线程池
 *    - 面试考点：线程池的优势，核心接口和实现类，与直接创建线程的对比
 *
 * 2. 线程池核心参数
 *    - corePoolSize：核心线程数，线程池保持活跃的最小线程数
 *    - maximumPoolSize：最大线程数，线程池允许创建的最大线程数
 *    - keepAliveTime：非核心线程的空闲存活时间
 *    - workQueue：工作队列，存储等待执行的任务
 *      a) ArrayBlockingQueue：有界队列，FIFO，需指定容量
 *      b) LinkedBlockingQueue：可选有界/无界队列，FIFO
 *      c) SynchronousQueue：不存储元素的队列，直接交付任务
 *      d) PriorityBlockingQueue：优先级队列，按优先级执行任务
 *    - threadFactory：线程工厂，用于创建新线程
 *    - handler：拒绝策略，队列已满且线程数达到maximumPoolSize时的处理策略
 *      a) AbortPolicy：默认策略，抛出RejectedExecutionException
 *      b) CallerRunsPolicy：由调用线程执行任务
 *      c) DiscardPolicy：直接丢弃任务
 *      d) DiscardOldestPolicy：丢弃队列最前面的任务，然后重新提交当前任务
 *    - 面试考点：各参数的含义和影响，如何根据业务场景选择合适的参数
 *
 * 3. 线程池的工作原理
 *    - 提交任务流程：
 *      a) 线程数 < corePoolSize：创建新线程执行任务
 *      b) 线程数 >= corePoolSize：任务入队列
 *      c) 队列已满且线程数 < maximumPoolSize：创建新线程执行任务
 *      d) 队列已满且线程数 >= maximumPoolSize：触发拒绝策略
 *    - 线程回收机制：
 *      a) 核心线程默认不回收（可设置allowCoreThreadTimeOut）
 *      b) 非核心线程空闲超过keepAliveTime会被回收
 *    - 任务执行顺序：
 *      a) 直接申请线程执行
 *      b) 入队等待执行
 *      c) 创建临时线程执行
 *      d) 拒绝任务
 *    - 面试考点：执行流程、线程池状态转换、线程池监控方法
 *
 * 4. 常用线程池类型
 *    - newFixedThreadPool：固定大小线程池
 *      特点：核心线程=最大线程，任务队列无界，适合负载稳定的场景
 *    - newCachedThreadPool：缓存线程池
 *      特点：核心线程=0，最大线程=Integer.MAX_VALUE，队列为SynchronousQueue，空闲60秒回收，适合短期异步小任务
 *    - newScheduledThreadPool：定时线程池
 *      特点：支持定时或周期性执行任务
 *    - newSingleThreadExecutor：单线程池
 *      特点：只有一个工作线程，保证任务顺序执行
 *    - newWorkStealingPool (Java 8)：工作窃取线程池
 *      特点：使用ForkJoinPool实现，适合任务拆分的场景
 *    - 自定义ThreadPoolExecutor：
 *      适合需要精细控制线程池参数的场景
 *    - 面试考点：各类线程池的使用场景和区别，线程池陷阱（newFixedThreadPool队列无界可能OOM）
 *
 * 5. Android中的线程池
 *    - AsyncTask内部线程池：
 *      a) 核心线程数与CPU核心数相关
 *      b) Android 3.0前使用newSingleThreadExecutor
 *      c) Android 11后内部使用Executor.newFixedThreadPool
 *      d) 注意AsyncTask可能引起内存泄漏
 *    - ThreadPoolExecutor.DiscardOldestPolicy：
 *      在Android中使用时需谨慎，可能丢弃重要任务
 *    - 系统线程池：
 *      a) AndroidThreads.THREAD_POOL_EXECUTOR
 *      b) AsyncTask.THREAD_POOL_EXECUTOR
 *    - Android线程池最佳实践：
 *      a) IO密集型任务：线程数 = CPU核心数 * (1 + IO耗时/CPU耗时)
 *      b) CPU密集型任务：线程数 ≈ CPU核心数 + 1
 *      c) 避免在不同组件间共享线程池
 *      d) 避免提交大量长时间运行的任务
 *    - 面试考点：Android系统线程池配置，AsyncTask线程池演变，针对Android优化的线程池配置
 *
 * 6. 线程池监控与调优
 *    - 监控指标：
 *      a) 活跃线程数：getActiveCount()
 *      b) 已完成任务数：getCompletedTaskCount()
 *      c) 队列大小：getQueue().size()
 *      d) 线程池状态：isShutdown(), isTerminated()
 *    - 常见问题及解决：
 *      a) 线程池任务堆积：调整队列容量，增加线程数
 *      b) 频繁拒绝任务：调整最大线程数，选择合适的拒绝策略
 *      c) 线程池未释放：确保显式调用shutdown()
 *      d) 过多线程导致竞争：适当减少线程数，调整任务粒度
 *    - 线程池调优原则：
 *      a) IO密集型：线程数 > CPU核心数，减少等待
 *      b) CPU密集型：线程数 ≈ CPU核心数，减少切换开销
 *      c) 混合型：需要分析任务特性，找平衡点
 *    - Android调优特点：
 *      a) 考虑手机电量和发热问题
 *      b) 考虑不同Android设备性能差异
 *      c) 主线程不宜提交过多任务到线程池
 *    - 面试考点：线程池调优参数选择的依据，监控方法，如何处理线程池异常
 *
 * 7. Future与线程池的结合
 *    - Future接口：表示异步计算的结果
 *      a) isDone()：检查任务是否完成
 *      b) get()：获取计算结果，会阻塞
 *      c) get(timeout, unit)：超时获取
 *      d) cancel(mayInterruptIfRunning)：取消任务
 *    - FutureTask类：实现了Future接口，表示可取消的异步计算
 *    - CompletableFuture (Java 8)：组合多个异步计算，支持链式操作
 *    - 使用场景：
 *      a) 并行计算结果合并
 *      b) 异步操作结果获取
 *      c) 任务执行超时控制
 *    - Android中的替代方案：
 *      a) RxJava：更灵活的异步操作框架
 *      b) Kotlin协程：简化异步编程
 *    - 面试考点：Future与线程池的结合使用，如何取消正在执行的任务，处理异步任务的异常
 *
 * 8. 线程池的正确关闭
 *    - shutdown()：平滑关闭，不接收新任务，执行完已提交任务
 *    - shutdownNow()：立即关闭，尝试中断所有任务，返回等待执行的任务列表
 *    - awaitTermination(timeout, unit)：等待所有任务完成或超时
 *    - isShutdown()/isTerminated()：检查线程池状态
 *    - 优雅关闭建议：
 *      a) 先调用shutdown()
 *      b) 使用awaitTermination等待一段时间
 *      c) 超时后可考虑shutdownNow()
 *    - Android中的关闭时机：
 *      a) Activity.onDestroy()
 *      b) Service.onDestroy()
 *      c) Application.onTerminate()
 *    - 面试考点：线程池关闭方法的区别，如何确保所有任务执行完毕，优雅关闭的策略
 *
 * 三、Android中的线程处理机制
 *
 * 1. Android主线程（UI线程）
 *    - 职责：处理UI交互，执行Activity/Fragment生命周期方法
 *    - 特性：单线程模型，所有UI操作必须在主线程执行
 *    - 限制：主线程不能执行耗时操作，否则导致ANR
 *      a) Activity：5秒内无响应
 *      b) BroadcastReceiver：10秒内无响应
 *      c) Service：20秒内无响应
 *    - Looper-Handler-MessageQueue：主线程消息循环机制
 *    - 面试考点：如何检测和避免主线程阻塞，ANR的原因和解决方案
 *
 * 2. Handler机制
 *    - 组成部分：
 *      a) Handler：发送和处理消息
 *      b) Message/Runnable：消息载体
 *      c) MessageQueue：消息队列，FIFO
 *      d) Looper：消息循环，不断从队列取出消息执行
 *    - 工作原理：
 *      a) 创建Handler关联Looper
 *      b) 通过Handler发送消息到MessageQueue
 *      c) Looper循环取出消息分发给Handler处理
 *    - 线程间通信：主线程Handler在子线程中执行post/sendMessage实现
 *    - 内存泄漏：非静态内部类Handler持有外部Activity引用
 *    - 面试考点：完整描述Handler原理，解决Handler内存泄漏问题
 *
 * 3. AsyncTask
 *    - 设计目的：简化UI线程与工作线程交互
 *    - 核心方法：
 *      a) onPreExecute()：主线程，任务执行前调用
 *      b) doInBackground()：工作线程，执行耗时操作
 *      c) onProgressUpdate()：主线程，更新进度
 *      d) onPostExecute()：主线程，任务完成后结果处理
 *    - 注意事项：
 *      a) Android 3.0后单任务串行执行
 *      b) 生命周期问题，Activity销毁但任务仍在执行
 *      c) 内存泄漏风险
 *      d) Android 11 (API 30)标记为废弃
 *    - 替代方案：协程、RxJava、LiveData+ViewModel
 *    - 面试考点：AsyncTask缺陷，为何被废弃，生命周期问题解决方案
 *
 * 4. HandlerThread
 *    - 描述：具有消息循环的工作线程，自带Looper
 *    - 特点：
 *      a) 继承Thread，在run方法中创建Looper
 *      b) 适合串行处理后台任务
 *      c) 优于普通Thread+Handler的组合
 *    - 使用场景：
 *      a) IntentService内部使用
 *      b) 需要长时间在后台运行的任务
 *      c) 有序消息处理
 *    - 注意事项：
 *      a) 单线程执行，任务会排队
 *      b) 需要手动调用quit()/quitSafely()
 *    - 面试考点：HandlerThread与普通Thread+Handler区别，适用场景分析
 *
 * 5. IntentService
 *    - 设计目的：封装HandlerThread的Service
 *    - 特点：
 *      a) 自动创建工作线程
 *      b) 任务执行完自动停止
 *      c) 任务队列串行执行
 *    - 实现原理：
 *      a) onCreate()中创建HandlerThread
 *      b) onStart()发送消息到工作线程Handler
 *      c) onHandleIntent()在工作线程中执行具体任务
 *    - 生命周期管理：
 *      a) 任务队列空时自动调用stopSelf()
 *      b) 新任务到来时Service保持活跃
 *    - Android 10 (API 29)中已废弃
 *    - 替代方案：JobIntentService、WorkManager、Foreground Service
 *    - 面试考点：IntentService工作原理，为何废弃，与Service区别
 *
 * 6. Android线程优先级
 *    - 主线程：优先级最高(THREAD_PRIORITY_DISPLAY, -4)
 *    - 前台线程：THREAD_PRIORITY_FOREGROUND(-2)
 *    - 普通线程：THREAD_PRIORITY_DEFAULT(0)
 *    - 后台线程：THREAD_PRIORITY_BACKGROUND(10)
 *    - 设置方法：android.os.Process.setThreadPriority()
 *    - 名称设置：Thread.setName()，利于调试
 *    - 面试考点：不同线程优先级的应用场景，如何根据任务特点选择合适优先级
 *
 * 7. WorkManager
 *    - 设计目的：执行可延迟、可保证完成的后台任务
 *    - 特点：
 *      a) 设备重启后任务恢复
 *      b) 考虑系统条件约束（电量、网络等）
 *      c) 遵循省电优化
 *      d) 支持链式任务和并行任务
 *    - 工作原理：
 *      a) 底层基于JobScheduler或自定义AlarmManager+Broadcast实现
 *      b) 任务执行时机由系统决定
 *    - 使用场景：
 *      a) 数据同步、日志上传
 *      b) 定期缓存清理
 *      c) 可延迟的后台任务
 *    - 面试考点：WorkManager底层实现机制，与其他后台处理方案对比
 *
 * 8. Kotlin协程
 *    - 特点：
 *      a) 轻量级线程，非阻塞
 *      b) 结构化并发，父子关系清晰
 *      c) 取消传播机制，取消父协程会取消子协程
 *      d) 上下文切换简洁
 *    - 核心概念：
 *      a) CoroutineScope：协程作用域
 *      b) CoroutineContext：协程上下文
 *      c) CoroutineDispatcher：协程调度器，决定协程运行线程
 *      d) Job：协程任务，可控制生命周期
 *    - Android中的使用：
 *      a) viewModelScope：绑定ViewModel生命周期
 *      b) lifecycleScope：绑定Lifecycle生命周期
 *      c) MainScope：主线程作用域
 *    - 与线程的关系：协程是运行在线程上的轻量级任务
 *    - 面试考点：协程与线程区别，协程的取消原理，作用域选择依据
 *
 * 四、常见面试题及解答
 *
 * 1. 线程和进程的区别？Android中主线程的作用是什么？
 *    答：线程是CPU调度的基本单位，而进程是资源分配的基本单位。线程共享所属进程的资源，进程之间相互独立。
 *        Android中，一个应用通常对应一个进程，主线程（UI线程）负责处理所有UI交互和组件生命周期事件。
 *        所有影响UI的操作必须在主线程执行，否则会抛出CalledFromWrongThreadException异常。
 *        主线程不应执行耗时操作，否则会导致ANR（应用无响应）问题。
 *
 * 2. synchronized和volatile关键字的区别？
 *    答：区别在于：
 *        1) 作用对象：synchronized可以修饰方法和代码块；volatile只能修饰变量
 *        2) 解决问题：synchronized解决原子性、可见性、有序性问题；volatile只解决可见性和有序性问题
 *        3) 实现机制：synchronized通过监视器锁（monitor）实现互斥；volatile通过内存屏障和禁止指令重排实现
 *        4) 性能影响：synchronized可能导致线程阻塞；volatile不会造成阻塞，但无法解决复合操作原子性问题
 *        5) 使用场景：synchronized适用于操作复杂的资源同步；volatile适用于简单的状态标记和单例模式双重检查
 *
 * 3. ThreadLocal的原理及在Android中的应用？
 *    答：ThreadLocal为每个线程提供变量的独立副本，解决线程安全问题的一种方式。
 *        原理：每个Thread内部维护一个ThreadLocalMap，key是ThreadLocal对象，value是存储的值。
 *        当访问ThreadLocal变量时，获取当前线程的ThreadLocalMap，然后根据ThreadLocal对象获取值。
 *        
 *        Android应用：
 *        1) Looper.prepare()创建ThreadLocal<Looper>
 *        2) ActivityThread的sCurrentActivityThread保存当前主线程ActivityThread
 *        3) Handler.mLooper通过ThreadLocal.get()获取当前线程Looper
 *        
 *        注意内存泄漏风险：ThreadLocalMap的key是ThreadLocal的弱引用，但value是强引用。
 *        如果ThreadLocal对象被回收，而线程未结束，可能导致value无法被回收，产生内存泄漏。
 *        解决方案是在不需要时调用remove()方法。
 *
 * 4. Android中线程池的正确使用方式？如何避免OOM？
 *    答：Android中线程池使用建议：
 *        1) 区分不同类型任务使用不同线程池：IO密集型和CPU密集型
 *        2) 线程数量控制：CPU密集型任务线程数≈CPU核心数+1；IO密集型任务可适当增加
 *        3) 避免使用Executors工厂方法创建（可能导致OOM），推荐直接创建ThreadPoolExecutor
 *        4) 为线程池设置合理的任务队列容量，避免无界队列
 *        5) 选择合适的拒绝策略，不要使用默认的AbortPolicy（会抛异常）
 *        6) 在组件销毁时及时关闭线程池（如Activity.onDestroy）
 *        
 *        避免OOM关键点：
 *        1) 使用有界队列代替无界队列（如LinkedBlockingQueue）
 *        2) 设置合理的线程数上限，避免创建过多线程
 *        3) 避免向线程池提交大量长期运行任务
 *        4) 对提交任务进行大小限制，防止处理超大任务
 *
 * 5. 解释Handler机制原理，如何避免Handler导致的内存泄漏？
 *    答：Handler机制原理：
 *        1) Looper：每个线程最多一个，通过Looper.prepare()创建，负责循环从MessageQueue取出消息
 *        2) MessageQueue：消息队列，按时间顺序存储待处理消息
 *        3) Handler：发送(post/sendMessage)和处理消息(handleMessage)，关联一个Looper
 *        4) Message：消息载体，包含what/arg1/arg2/obj/target(Handler)等
 *        
 *        工作流程：Handler发送消息 → 消息进入MessageQueue → Looper循环取出消息 → 
 *        调用Message的target(Handler)处理消息
 *        
 *        内存泄漏原因：非静态内部类Handler持有外部类引用（如Activity），若消息队列中
 *        有未处理的消息且持有Handler引用，会导致Activity无法被回收。
 *        
 *        避免内存泄漏方法：
 *        1) 使用静态内部类+弱引用：
 *           ```java
 *           private static class MyHandler extends Handler {
 *               private final WeakReference<Activity> activityRef;
 *               // ...
 *           }
 *           ```
 *        2) 在Activity.onDestroy()中removeCallbacksAndMessages(null)
 *        3) 使用生命周期感知组件，如ViewModel中的viewModelScope
 *
 * 6. 描述一下线程池的工作原理及参数选择策略？
 *    答：工作原理：
 *        1) 核心线程优先：任务到达时，如果线程数<核心线程数，创建新线程
 *        2) 任务入队列：如果核心线程都在工作，任务进入工作队列
 *        3) 创建临时线程：队列已满，且线程数<最大线程数，创建临时线程
 *        4) 触发拒绝策略：队列已满，且线程数=最大线程数
 *        
 *        参数选择策略：
 *        1) 核心线程数(corePoolSize)：
 *           - CPU密集型：CPU核心数+1
 *           - IO密集型：CPU核心数*2
 *           - 混合型：CPU核心数*(1+平均等待时间/平均工作时间)
 *        2) 最大线程数(maximumPoolSize)：
 *           - 考虑内存、线程切换开销，通常不超过CPU核心数*5
 *           - Android中建议保守设置，考虑电量和系统资源
 *        3) 空闲线程存活时间(keepAliveTime)：
 *           - 短期任务：设置较短时间（如30秒）
 *           - 波动型负载：设置较长时间（如几分钟）
 *        4) 工作队列(workQueue)：
 *           - 任务数确定：ArrayBlockingQueue，设定合理容量
 *           - 任务数不确定：LinkedBlockingQueue，设置容量上限
 *           - 任务需按优先级：PriorityBlockingQueue
 *           - 任务无需排队直接执行：SynchronousQueue
 *        5) 拒绝策略(handler)：
 *           - 一般场景：CallerRunsPolicy（降级执行）
 *           - 可丢弃场景：DiscardPolicy（日志任务等）
 *           - 自定义策略：实现RejectedExecutionHandler接口
 *        
 *        Android特有考量：
 *        - 主线程不应运行重任务
 *        - 考虑电量和发热影响
 *        - 考虑不同设备性能差异
 *
 * 7. AsyncTask为什么被废弃？现在推荐什么替代方案？
 *    答：AsyncTask废弃原因：
 *        1) 生命周期问题：不会随Activity/Fragment生命周期自动取消
 *        2) 配置变更问题：屏幕旋转等导致Activity重建，任务会丢失或重复执行
 *        3) 内存泄漏风险：持有外部引用可能导致泄漏
 *        4) 版本变更导致行为不一致：不同Android版本串行/并行执行行为不同
 *        5) 结果处理复杂：需要手动处理异常和取消
 *        6) 不支持链式调用和组合操作
 *        
 *        推荐替代方案：
 *        1) Kotlin协程 + lifecycleScope/viewModelScope：
 *           - 自动关联生命周期
 *           - 结构化并发，易于取消
 *           - 异常处理机制完善
 *           - 代码简洁直观
 *        2) LiveData + ViewModel + Repository：
 *           - 遵循MVVM架构
 *           - 生命周期感知
 *           - 数据驱动UI更新
 *        3) RxJava：
 *           - 强大的操作符
 *           - 完善的线程控制和异常处理
 *           - 适合复杂异步场景
 *        4) WorkManager：
 *           - 适合后台任务，即使应用退出也能保证执行
 *           - 支持约束条件和定期执行
 *
 * 8. Android中有哪些容易导致内存泄漏的多线程场景？如何解决？
 *    答：常见内存泄漏场景：
 *        1) Handler引起：非静态内部类Handler持有Activity引用
 *        2) Thread/Runnable：匿名内部类Thread/Runnable持有外部类引用
 *        3) AsyncTask：同样持有外部引用问题
 *        4) ThreadLocal使用不当：未调用remove()方法
 *        5) 线程池：提交的任务持有Activity引用且长时间运行
 *        6) Timer/TimerTask：未取消的定时任务
 *        7) RxJava订阅：未正确解除订阅
 *        
 *        解决方案：
 *        1) Handler：使用静态内部类+弱引用，Activity销毁时清空消息
 *        2) Thread/Runnable：使用静态内部类或在生命周期结束时中断线程
 *        3) AsyncTask：使用静态内部类，在onDestroy中取消任务
 *        4) ThreadLocal：在不需要时调用remove()方法
 *        5) 线程池：组件销毁时关闭线程池或取消任务
 *        6) Timer/TimerTask：在onDestroy中调用cancel()方法
 *        7) RxJava：使用CompositeDisposable管理订阅，并在onDestroy中调用clear()
 *        8) 使用生命周期感知组件：如LiveData、Lifecycle、ViewModel
 *        9) 使用弱引用持有上下文或视图引用
 *
 * 9. 为什么不能在子线程中更新UI？Android的线程模型是怎样的？
 *    答：不能在子线程更新UI的原因：
 *        1) 线程安全问题：UI组件非线程安全，多线程并发修改可能导致不可预期结果
 *        2) 效率问题：若允许多线程访问UI，需要加锁，影响UI渲染性能
 *        3) 一致性问题：视图状态的一致性难以保证
 *        
 *        Android线程模型：
 *        1) 单线程模型：所有UI操作必须在主线程（UI线程）执行
 *        2) 基于消息机制：通过Handler将子线程工作结果发送到主线程更新UI
 *        3) 主线程Looper永不退出：在ActivityThread.main()中，主线程Looper.loop()进入无限循环
 *        4) 组件生命周期方法：均在主线程被调用（如onCreate、onStart等）
 *        5) 子线程通信到主线程的方式：
 *           - Handler机制（最常用）
 *           - Activity.runOnUiThread()
 *           - View.post()/postDelayed()
 *           - LiveData/协程等框架提供的线程切换机制
 *
 * 10. 如何理解Android中的线程优先级？不同场景应如何设置？
 *     答：Android线程优先级：
 *         1) 基于Linux进程优先级，范围-20到19，数值越小优先级越高
 *         2) 通过Process.setThreadPriority()设置，而非Thread.setPriority()
 *         
 *         常用优先级常量：
 *         - THREAD_PRIORITY_AUDIO (-16)：音频处理线程
 *         - THREAD_PRIORITY_DISPLAY (-4)：UI/动画处理
 *         - THREAD_PRIORITY_FOREGROUND (-2)：用户交互相关前台操作
 *         - THREAD_PRIORITY_DEFAULT (0)：默认优先级
 *         - THREAD_PRIORITY_BACKGROUND (10)：后台任务，不需要用户感知
 *         
 *         优先级设置策略：
 *         1) 即时响应型任务：设置较高优先级（如FOREGROUND）
 *            - 用户输入处理
 *            - 动画渲染
 *            - 视频/音频播放
 *         2) 可延迟响应型任务：使用默认优先级
 *            - 网络请求
 *            - 数据解析
 *            - 普通计算任务
 *         3) 后台任务：设置低优先级（如BACKGROUND）
 *            - 数据同步备份
 *            - 缓存清理
 *            - 日志上传
 *            - 预加载
 *         
 *         注意事项：
 *         1) 避免所有线程都设为高优先级，会导致优先级失效
 *         2) 后台线程应合理让出资源，避免影响前台体验
 *         3) 考虑电池消耗，低电量时应降低非关键任务优先级
 */
public class ThreadDoc {
    // 这是一个文档类，只包含注释，没有实际代码
} 